home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C++ / Frameworks / Sprocket Framework DR2 / Sprocket Framework / UResources.cp < prev    next >
Text File  |  1996-06-15  |  10KB  |  586 lines
  1. /*
  2.  
  3.     File:        UResources.cp
  4.     Project:    Sprocket Framework 1.1 (DR2), released 6/15/96
  5.     Contains:    Resource compatibilty routines which do the right thing for System 7 or 8
  6.                 If compiling for MacOS 8 only, calls are mapped directly without any glue
  7.     To Do:        ?
  8.  
  9.     Sprocket Major Contributors:
  10.     ----------------------------
  11.     Dave Falkenburg, producer of Sprocket 1.0
  12.     Bill Hayden,     producer of Sprocket 1.1
  13.     Steve Sisak,     producer of the upcoming Sprocket 2.0
  14.     
  15.     Pete Alexander        Steve Falkenburg    Randy Thelen
  16.     Eric Berdahl        Nitin Ganatra        Chris K. Thomas
  17.     Marshall Clow        Dave Hershey        Leonard Rosenthal
  18.     Tim Craycroft        Dave Mark            Dean Yu
  19.     David denBoer        Gary Powell
  20.     Cameron Esfahani    Jon Summers            Apple Computer, Inc.
  21.         
  22.     Comments, Additions, or Corrections:
  23.     ------------------------------------
  24.     Bill Hayden, Nikol Software <nikol@codewell.com>
  25.  
  26. */
  27.  
  28. // If we are compiling only for MacOS 8 or later only, we don’t need any of this.
  29. // This is for savvy binary compatibility between System 7 and MacOS 8 only.
  30.  
  31.  
  32. #if (!BUILDING_FOR_SYSTEM8)
  33.  
  34. #include "Sprocket.h"
  35. #include "UResources.h"
  36.  
  37.  
  38. // This may come in handy at some later time.
  39.  
  40. #define System8ResourceManagerUnavailable    ( GENERATING68K || (gSystemVersion < 0x0800) )
  41.  
  42.  
  43.  
  44. OSStatus RMCloseResFileCompat(ResFileRefNum refNum)
  45. {
  46.     if (System8ResourceManagerUnavailable)
  47.         {
  48.         CloseResFile(refNum);
  49.         
  50.         return ResError();
  51.         }
  52. #if GENERATINGPOWERPC
  53.     else
  54.         return RMCloseResFile(refNum);
  55. #endif
  56. }
  57.  
  58.  
  59.  
  60. OSStatus RMUpdateResFileCompat(ResFileRefNum refNum)
  61. {
  62.     if (System8ResourceManagerUnavailable)
  63.         {
  64.         UpdateResFile(refNum);
  65.         
  66.         return ResError();
  67.         }
  68. #if GENERATINGPOWERPC
  69.     else
  70.         return RMUpdateResFile(refNum);
  71. #endif
  72. }
  73.  
  74.  
  75.  
  76. OSStatus RMUseResFileCompat(ResFileRefNum refNum)
  77. {
  78.     if (System8ResourceManagerUnavailable)
  79.         {
  80.         UseResFile(refNum);
  81.         
  82.         return ResError();
  83.         }
  84. #if GENERATINGPOWERPC
  85.     else
  86.         return RMUseResFile(refNum);
  87. #endif
  88. }
  89.  
  90.  
  91.  
  92. OSStatus RMCurResFileCompat(ResFileRefNum* refNum)
  93. {
  94.     if (System8ResourceManagerUnavailable)
  95.         {
  96.         *refNum = CurResFile();
  97.         
  98.         return ResError();
  99.         }
  100. #if GENERATINGPOWERPC
  101.     else
  102.         return RMCurResFile(refNum);
  103. #endif
  104. }
  105.  
  106.  
  107.  
  108. OSStatus RMHomeResFileCompat(Handle theResource, ResFileRefNum *refNum)
  109. {
  110.     if (System8ResourceManagerUnavailable)
  111.         {
  112.         *refNum = HomeResFile(theResource);
  113.         
  114.         return ResError();
  115.         }
  116. #if GENERATINGPOWERPC
  117.     else
  118.         return RMHomeResFile(theResource, refNum);
  119. #endif
  120. }
  121.  
  122.  
  123.  
  124. OSStatus RMAddResourceCompat(Handle theData, ResType theType, ResID theID, ConstStr255Param name)
  125. {
  126.     if (System8ResourceManagerUnavailable)
  127.         {
  128.         AddResource(theData, theType, theID, name);
  129.         
  130.         return ResError();
  131.         }
  132. #if GENERATINGPOWERPC
  133.     else
  134.         return RMAddResource(theData, theType, theID, name);
  135. #endif
  136. }
  137.  
  138.  
  139.  
  140. OSStatus RMRemoveResourceCompat(Handle theResource)
  141. {
  142.     if (System8ResourceManagerUnavailable)
  143.         {
  144.         RemoveResource(theResource);
  145.         
  146.         return ResError();
  147.         }
  148. #if GENERATINGPOWERPC
  149.     else
  150.         return RMRemoveResource(theResource);
  151. #endif
  152. }
  153.  
  154.  
  155.  
  156. OSStatus RMCountTypesCompat(Boolean oneDeep, UInt32 *count)
  157. {
  158.     if (System8ResourceManagerUnavailable)
  159.         {
  160.         if(oneDeep)
  161.             *count = Count1Types();
  162.         else
  163.             *count = CountTypes();
  164.         
  165.         return ResError();
  166.         }
  167. #if GENERATINGPOWERPC
  168.     else
  169.         return RMCountTypes(oneDeep, count);
  170. #endif
  171. }
  172.  
  173.  
  174.  
  175. OSStatus RMGetIndexedTypeCompat(UInt32 index, Boolean oneDeep, ResType *theType)
  176. {
  177.     if (System8ResourceManagerUnavailable)
  178.         {
  179.         if(oneDeep)
  180.             Get1IndType(theType, index);
  181.         else
  182.             GetIndType(theType, index);
  183.         
  184.         return ResError();
  185.         }
  186. #if GENERATINGPOWERPC
  187.     else
  188.         return RMGetIndexedType(index, oneDeep, theType);
  189. #endif
  190. }
  191.  
  192.  
  193.  
  194. OSStatus RMCountResourcesCompat(ResType theType, Boolean oneDeep, UInt32 *count)
  195. {
  196.     if (System8ResourceManagerUnavailable)
  197.         {
  198.         if(oneDeep)
  199.             *count = Count1Resources(theType);
  200.         else
  201.             *count = CountResources(theType);
  202.             
  203.         return ResError();
  204.         }
  205. #if GENERATINGPOWERPC
  206.     else
  207.         return RMCountResources(theType, oneDeep, count);
  208. #endif
  209. }
  210.  
  211.  
  212.  
  213. OSStatus RMGetIndexedResourceCompat(ResType theType, UInt32 index, Boolean oneDeep, Boolean resLoad, Handle *handle)
  214. {
  215.     if (System8ResourceManagerUnavailable)
  216.         {
  217.         OSStatus    err = 0L;
  218.         UInt8        saveResLoad;
  219.     
  220.     
  221.         saveResLoad = LMGetResLoad();
  222.         SetResLoad(resLoad);
  223.         
  224.         if(oneDeep)
  225.             *handle = Get1IndResource(theType, index);
  226.         else
  227.             *handle = GetIndResource(theType, index);
  228.         
  229.         err = ResError();
  230.         
  231.         SetResLoad(saveResLoad);
  232.         return err;
  233.         }
  234. #if GENERATINGPOWERPC
  235.     else
  236.         return RMGetIndexedResource(theType, index, oneDeep, resLoad, handle);
  237. #endif
  238. }
  239.  
  240.  
  241.  
  242. OSStatus RMGetResourceCompat(ResType theType, ResID theID, Boolean oneDeep, Boolean resLoad, Handle *handle)
  243. {
  244.     if (System8ResourceManagerUnavailable)
  245.         {
  246.         OSStatus    err;
  247.         UInt8        saveResLoad;
  248.  
  249.         
  250.         saveResLoad = LMGetResLoad();
  251.         SetResLoad(resLoad);
  252.         
  253.         if(oneDeep)
  254.             *handle = Get1Resource(theType, theID);
  255.         else
  256.             *handle = GetResource(theType, theID);
  257.         
  258.         err = ResError();
  259.         
  260.         SetResLoad(saveResLoad);
  261.         return err;
  262.         }
  263. #if GENERATINGPOWERPC
  264.     else
  265.         return RMGetResource(theType, theID, oneDeep, resLoad, handle);
  266. #endif
  267. }
  268.  
  269.  
  270.  
  271. OSStatus RMGetNamedResourceCompat(ResType theType, ConstStr255Param name, Boolean oneDeep, Boolean resLoad, Handle *handle)
  272. {
  273.     if (System8ResourceManagerUnavailable)
  274.         {
  275.         OSStatus    err;
  276.         UInt8        saveResLoad;
  277.         
  278.         
  279.         saveResLoad = LMGetResLoad();
  280.         SetResLoad(resLoad);
  281.         
  282.         if(oneDeep)
  283.             *handle = Get1NamedResource(theType, name);
  284.         else
  285.             *handle = GetNamedResource(theType, name);
  286.         
  287.         err = ResError();
  288.         
  289.         SetResLoad(saveResLoad);
  290.         return err;
  291.         }
  292. #if GENERATINGPOWERPC
  293.     else
  294.         return RMGetNamedResource(theType, name, oneDeep, resLoad, handle);
  295. #endif
  296. }
  297.  
  298.  
  299.  
  300. OSStatus RMLoadResourceCompat(Handle theResource)
  301. {
  302.     if (System8ResourceManagerUnavailable)
  303.         {
  304.         LoadResource(theResource);
  305.         
  306.         return ResError();
  307.         }
  308. #if GENERATINGPOWERPC
  309.     else
  310.         return RMLoadResource(theResource);
  311. #endif
  312. }
  313.  
  314.  
  315.  
  316. OSStatus RMReleaseResourceCompat(Handle theResource)
  317. {
  318.     if (System8ResourceManagerUnavailable)
  319.         {
  320.         ReleaseResource(theResource);
  321.         
  322.         return ResError();
  323.         }
  324. #if GENERATINGPOWERPC
  325.     else
  326.         return RMReleaseResource(theResource);
  327. #endif
  328. }
  329.  
  330.  
  331.  
  332. OSStatus RMDetachResourceCompat(Handle theResource)
  333. {
  334.     if (System8ResourceManagerUnavailable)
  335.         {
  336.         DetachResource(theResource);
  337.         
  338.         return ResError();
  339.         }
  340. #if GENERATINGPOWERPC
  341.     else
  342.         return RMDetachResource(theResource);
  343. #endif
  344. }
  345.  
  346.  
  347.  
  348. OSStatus RMChangedResourceCompat(Handle theResource)
  349. {
  350.     if (System8ResourceManagerUnavailable)
  351.         {
  352.         ChangedResource(theResource);
  353.         
  354.         return ResError();
  355.         }
  356. #if GENERATINGPOWERPC
  357.     else
  358.         return RMChangedResource(theResource);
  359. #endif
  360. }
  361.  
  362.  
  363.  
  364. OSStatus RMWriteResourceCompat(Handle theResource)
  365. {
  366.     if (System8ResourceManagerUnavailable)
  367.         {
  368.         WriteResource(theResource);
  369.         
  370.         return ResError();
  371.         }
  372. #if GENERATINGPOWERPC
  373.     else
  374.         return RMWriteResource(theResource);
  375. #endif
  376. }
  377.  
  378.  
  379.  
  380. OSStatus RMSetResourceSizeCompat(Handle theResource, SInt32 newSize)
  381. {
  382.     if (System8ResourceManagerUnavailable)
  383.         {
  384.         SetResourceSize(theResource, newSize);
  385.         
  386.         return ResError();
  387.         }
  388. #if GENERATINGPOWERPC
  389.     else
  390.         return RMSetResourceSize(theResource, newSize);
  391. #endif
  392. }
  393.  
  394.  
  395.  
  396. OSStatus RMUniqueIDCompat(ResType theType, Boolean oneDeep, ResID *idPtr)
  397. {
  398.     if (System8ResourceManagerUnavailable)
  399.         {
  400.         if(oneDeep)
  401.             *idPtr = Unique1ID(theType);
  402.         else
  403.             *idPtr = UniqueID(theType);
  404.         
  405.         return ResError();
  406.         }
  407. #if GENERATINGPOWERPC
  408.     else
  409.         return RMUniqueID(theType, oneDeep, idPtr);
  410. #endif
  411. }
  412.  
  413.  
  414.  
  415. OSStatus RMGetResAttributesCompat(Handle theResource, ResAttributes *attributes)
  416. {
  417.     if (System8ResourceManagerUnavailable)
  418.         {
  419.         *attributes = GetResAttrs(theResource);
  420.         
  421.         return ResError();
  422.         }
  423. #if GENERATINGPOWERPC
  424.     else
  425.         return RMGetResAttributes(theResource, attributes);
  426. #endif
  427. }
  428.  
  429.  
  430.  
  431. OSStatus RMGetResInfoCompat(Handle theResource, ResType *typePtr, ResID *idPtr, Str255 name)
  432. {
  433.     if (System8ResourceManagerUnavailable)
  434.         {
  435.         GetResInfo(theResource, idPtr, typePtr, name);
  436.         
  437.         return ResError();
  438.         }
  439. #if GENERATINGPOWERPC
  440.     else
  441.         return RMGetResInfo(theResource, typePtr, idPtr, name);
  442. #endif
  443. }
  444.  
  445.  
  446.  
  447. OSStatus RMSetResInfoCompat(Handle theResource, ResType typePtr, ResID theID, ConstStr255Param name)
  448. {
  449.     if (System8ResourceManagerUnavailable)
  450.         {
  451.         SetResInfo(theResource, theID, name);
  452.         
  453.         return ResError();
  454.         }
  455. #if GENERATINGPOWERPC
  456.     else
  457.         return RMSetResInfo(theResource, typePtr, theID, name);
  458. #else
  459.     #pragma unused(typePtr)
  460. #endif
  461. }
  462.  
  463.  
  464.  
  465. OSStatus RMSetResAttributesCompat(Handle theResource, ResAttributes attrs)
  466. {
  467.     if (System8ResourceManagerUnavailable)
  468.         {
  469.         SetResAttrs(theResource, attrs);
  470.         
  471.         return ResError();
  472.         }
  473. #if GENERATINGPOWERPC
  474.     else
  475.         return RMSetResAttributes(theResource, attrs);
  476. #endif
  477. }
  478.  
  479.  
  480.  
  481. OSStatus RMReadPartialResourceCompat(Handle theResource, UInt32 offset, void *buffer, UInt32 count)
  482. {
  483.     if (System8ResourceManagerUnavailable)
  484.         {
  485.         ReadPartialResource(theResource, offset, buffer, count);
  486.         
  487.         return ResError();
  488.         }
  489. #if GENERATINGPOWERPC
  490.     else
  491.         return RMReadPartialResource(theResource, offset, buffer, count);
  492. #endif
  493. }
  494.  
  495.  
  496. OSStatus RMWritePartialResourceCompat(Handle theResource, UInt32 offset, const void *buffer, UInt32 count)
  497. {
  498.     if (System8ResourceManagerUnavailable)
  499.         {
  500.         OSStatus    outErr = 0L;
  501.         
  502.         WritePartialResource(theResource, offset, buffer, count);
  503.         
  504.         outErr = ResError();
  505.         return outErr;
  506.         }
  507. #if GENERATINGPOWERPC
  508.     else
  509.         return RMWritePartialResource(theResource, offset, buffer, count);
  510. #endif
  511. }
  512.  
  513.  
  514.  
  515. OSStatus RMGetResourceSizeCompat(Handle theResource, SInt32 *size)
  516. {
  517.     if (System8ResourceManagerUnavailable)
  518.         {
  519.         *size = GetResourceSizeOnDisk(theResource);
  520.         
  521.         return ResError();
  522.         }
  523. #if GENERATINGPOWERPC
  524.     else
  525.         return RMGetResourceSize(theResource, size);
  526. #endif
  527. }
  528.  
  529.  
  530.  
  531. OSStatus RMSetResErrProcCompat(ResErrUPP proc)
  532. {
  533.     if (System8ResourceManagerUnavailable)
  534.         {
  535.         LMSetResErrProc(proc);
  536.         
  537.         return noErr;
  538.         }
  539. #if GENERATINGPOWERPC
  540.     else
  541.         return RMSetResErrProc(proc);
  542. #endif
  543. }
  544.  
  545.  
  546.  
  547. OSStatus RMSetResFileReadOnlyStateCompat(ResFileRefNum refNum, Boolean isReadOnly)
  548. {
  549.     if (System8ResourceManagerUnavailable)
  550.         {
  551.         SetResFileAttrs(refNum, isReadOnly ? mapReadOnly : 0);
  552.         
  553.         return ResError();
  554.         }
  555. #if GENERATINGPOWERPC
  556.     else
  557.         return RMSetResFileReadOnlyState(refNum, isReadOnly);
  558. #endif
  559. }
  560.  
  561.  
  562.  
  563. OSStatus RMGetResFileReadOnlyStateCompat(ResFileRefNum refNum, Boolean *isReadOnly)
  564. {
  565.     if (System8ResourceManagerUnavailable)
  566.         {
  567.         short        attrs;
  568.         
  569.         
  570.         attrs = GetResFileAttrs(refNum);
  571.         
  572.         if(attrs & mapReadOnly)
  573.             *isReadOnly = true;
  574.         else
  575.             *isReadOnly = false;
  576.         
  577.         return ResError();
  578.         }
  579. #if GENERATINGPOWERPC
  580.     else
  581.         return RMGetResFileReadOnlyState(refNum, isReadOnly);
  582. #endif
  583. }
  584.  
  585.  
  586. #endif